package config

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"gopkg.in/yaml.v3"
	"io/ioutil"
)

// ConfigService 配置服务
type ConfigService struct {
	configPath string
}

// NewConfigService 创建新的配置服务
func NewConfigService() *ConfigService {
	return &ConfigService{
		configPath: filepath.Join("config", "config.yaml"),
	}
}

// GetConfig 获取配置
func (s *ConfigService) GetConfig() (map[string]interface{}, error) {
	// 读取配置文件
	data, err := ioutil.ReadFile(s.configPath)
	if err != nil {
		return nil, fmt.Errorf("读取配置文件失败: %v", err)
	}

	// 检查并移除UTF-8 BOM头（如果存在）
	if len(data) >= 3 && data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF {
		data = data[3:]
	}

	// 解析YAML
	var config map[string]interface{}
	if err := yaml.Unmarshal(data, &config); err != nil {
		return nil, fmt.Errorf("解析配置文件失败: %v", err)
	}
	
	// 处理带引号的中文路径
	config = s.processQuotedPaths(config)

	return config, nil
}

// processQuotedPaths 处理带引号的中文路径，移除引号
func (s *ConfigService) processQuotedPaths(config map[string]interface{}) map[string]interface{} {
	result := make(map[string]interface{})
	
	for k, v := range config {
		switch val := v.(type) {
		case string:
			// 检查是否是被双引号括起来的字符串
			if len(val) >= 2 && strings.HasPrefix(val, "\"") && strings.HasSuffix(val, "\"") {
				result[k] = val[1 : len(val)-1]
			} else {
				result[k] = val
			}
		case map[string]interface{}:
			result[k] = s.processQuotedPaths(val)
		case []interface{}:
			var processedSlice []interface{}
			for _, item := range val {
				if str, ok := item.(string); ok {
					// 检查是否是被双引号括起来的字符串
					if len(str) >= 2 && strings.HasPrefix(str, "\"") && strings.HasSuffix(str, "\"") {
						processedSlice = append(processedSlice, str[1:len(str)-1])
					} else {
						processedSlice = append(processedSlice, str)
					}
				} else if subMap, ok := item.(map[string]interface{}); ok {
					processedSlice = append(processedSlice, s.processQuotedPaths(subMap))
				} else {
					processedSlice = append(processedSlice, item)
				}
			}
			// 特殊处理index_directories，确保路径正确且不带引号
			if k == "index_directories" {
				// 确保所有路径都不带引号
				var cleanPaths []interface{}
				for _, path := range processedSlice {
					if pathStr, ok := path.(string); ok {
						// 再次检查并移除可能的引号
						if len(pathStr) >= 2 && strings.HasPrefix(pathStr, "\"") && strings.HasSuffix(pathStr, "\"") {
							cleanPaths = append(cleanPaths, pathStr[1:len(pathStr)-1])
						} else {
							cleanPaths = append(cleanPaths, pathStr)
						}
					} else {
						cleanPaths = append(cleanPaths, path)
					}
				}
				result[k] = cleanPaths
			} else {
				result[k] = processedSlice
			}
		default:
			result[k] = val
		}
	}
	
	return result
}

// SaveConfig 保存配置
func (s *ConfigService) SaveConfig(newConfig map[string]interface{}) error {
	// 检查是否有data包装层，如果有则提取实际配置
	if data, ok := newConfig["data"].(map[string]interface{}); ok {
		newConfig = data
	}

	// 获取当前配置
	currentConfig, err := s.GetConfig()
	if err != nil {
		return fmt.Errorf("获取当前配置失败: %v", err)
	}

	// 合并配置
	mergedConfig := s.mergeConfig(currentConfig, newConfig)
	
	// 处理中文路径
	processedConfig := s.processChinesePaths(mergedConfig)

	// 确保配置目录存在
	configDir := filepath.Dir(s.configPath)
	if err := os.MkdirAll(configDir, 0755); err != nil {
		return fmt.Errorf("创建配置目录失败: %v", err)
	}

	// 序列化为YAML
	data, err := yaml.Marshal(processedConfig)
	if err != nil {
		return fmt.Errorf("序列化配置失败: %v", err)
	}

	// 写入文件
	// 添加UTF-8 BOM头以确保文件以UTF-8编码保存
	utf8BOM := []byte{0xEF, 0xBB, 0xBF}
	dataWithBOM := append(utf8BOM, data...)
	if err := ioutil.WriteFile(s.configPath, dataWithBOM, 0644); err != nil {
		return fmt.Errorf("写入配置文件失败: %v", err)
	}

	return nil
}

// mergeConfig 合并配置
func (s *ConfigService) mergeConfig(current, new map[string]interface{}) map[string]interface{} {
	result := make(map[string]interface{})

	// 复制当前配置
	for k, v := range current {
		result[k] = v
	}

	// 更新新配置
	for k, v := range new {
		if currentVal, exists := current[k]; exists {
			// 如果是map类型，递归合并
			if currentMap, ok := currentVal.(map[string]interface{}); ok {
				if newMap, ok := v.(map[string]interface{}); ok {
					result[k] = s.mergeConfig(currentMap, newMap)
					continue
				}
			}
		}
		// 直接替换
		result[k] = v
	}

	return result
}

// processChinesePaths 处理配置中的中文路径，确保不添加引号
func (s *ConfigService) processChinesePaths(config map[string]interface{}) map[string]interface{} {
	result := make(map[string]interface{})
	
	for k, v := range config {
		switch val := v.(type) {
		case string:
			// 确保不添加引号，直接使用原始值
			result[k] = val
		case map[string]interface{}:
			result[k] = s.processChinesePaths(val)
		case []interface{}:
			var processedSlice []interface{}
			for _, item := range val {
				if str, ok := item.(string); ok {
					// 确保不添加引号，直接使用原始值
					processedSlice = append(processedSlice, str)
				} else {
					processedSlice = append(processedSlice, item)
				}
			}
			result[k] = processedSlice
		default:
			result[k] = val
		}
	}
	
	return result
}

// containsChinese 检查字符串是否包含中文字符
func (s *ConfigService) containsChinese(str string) bool {
	for _, r := range str {
		if r >= '\u4e00' && r <= '\u9fff' {
			return true
		}
	}
	return false
}